home *** CD-ROM | disk | FTP | other *** search
/ ASME's Mechanical Engine…ing Toolkit 1997 December / ASME's Mechanical Engineering Toolkit 1997 December.iso / c_lang / sc.zoo / cmds.c next >
Encoding:
C/C++ Source or Header  |  1988-06-03  |  9.7 KB  |  541 lines
  1. /*    SC    A Spreadsheet Calculator
  2.  *        Main driver
  3.  *
  4.  *        original by James Gosling, September 1982
  5.  *        modifications by Mark Weiser and Bruce Israel,
  6.  *            University of Maryland
  7.  *
  8.  *              More mods Robert Bond, 12/86
  9.  *
  10.  */
  11.  
  12. #include <curses.h>
  13. #include "sc.h"
  14.  
  15. #ifdef BSD42
  16. #include <strings.h>
  17. #else
  18. #ifndef SYSIII
  19. #include <string.h>
  20. #endif
  21. #endif
  22.  
  23. duprow()
  24. {
  25.     if (currow >= MAXROWS - 1 || maxrow >= MAXROWS - 1) {
  26.     error ("The table can't be any bigger");
  27.     return;
  28.     }
  29.     modflg++;
  30.     currow++;
  31.     openrow (currow);
  32.     for (curcol = 0; curcol <= maxcol; curcol++) {
  33.     register struct ent *p = tbl[currow - 1][curcol];
  34.     if (p) {
  35.         register struct ent *n;
  36.         n = lookat (currow, curcol);
  37.         n -> v = p -> v;
  38.         n -> flags = p -> flags;
  39.         n -> expr = copye (p -> expr, 1, 0);
  40.         n -> label = 0;
  41.         if (p -> label) {
  42.         n -> label = (char *)
  43.                  xmalloc ((unsigned)(strlen (p -> label) + 1));
  44.         (void) strcpy (n -> label, p -> label);
  45.         }
  46.     }
  47.     }
  48.     for (curcol = 0; curcol <= maxcol; curcol++) {
  49.     register struct ent *p = tbl[currow][curcol];
  50.     if (p && (p -> flags & is_valid) && !p -> expr)
  51.         break;
  52.     }
  53.     if (curcol > maxcol)
  54.     curcol = 0;
  55. }
  56.  
  57. dupcol() 
  58. {
  59.     if (curcol >= MAXCOLS - 1 || maxcol >= MAXCOLS - 1) {
  60.     error ("The table can't be any wider");
  61.     return;
  62.     }
  63.     modflg++;
  64.     curcol++;
  65.     opencol (curcol);
  66.     for (currow = 0; currow <= maxrow; currow++) {
  67.     register struct ent *p = tbl[currow][curcol - 1];
  68.     if (p) {
  69.         register struct ent *n;
  70.         n = lookat (currow, curcol);
  71.         n -> v = p -> v;
  72.         n -> flags = p -> flags;
  73.         n -> expr = copye (p -> expr, 0, 1);
  74.         n -> label = 0;
  75.         if (p -> label) {
  76.         n -> label = (char *)
  77.                  xmalloc ((unsigned) (strlen (p -> label) + 1));
  78.         (void) strcpy (n -> label, p -> label);
  79.         }
  80.     }
  81.     }
  82.     for (currow = 0; currow <= maxrow; currow++) {
  83.     register struct ent *p = tbl[currow][curcol];
  84.     if (p && (p -> flags & is_valid) && !p -> expr)
  85.         break;
  86.     }
  87.     if (currow > maxrow)
  88.     currow = 0;
  89. }
  90.  
  91. insertrow(arg)
  92. {
  93.     while (--arg>=0) openrow (currow);
  94. }
  95.  
  96. deleterow(arg)
  97. {
  98.     flush_saved();
  99.     erase_area(currow, 0, currow + arg - 1, maxcol);
  100.     currow += arg;
  101.     while (--arg>=0) closerow (--currow);
  102.     sync_refs();
  103. }
  104.  
  105. insertcol(arg)
  106. {
  107.     while (--arg>=0) opencol(curcol);
  108. }
  109.  
  110. deletecol(arg)
  111. {
  112.     flush_saved();
  113.     erase_area(0, curcol, maxrow, curcol + arg - 1);
  114.     curcol += arg;
  115.     while (--arg>=0) closecol (--curcol);
  116.     sync_refs();
  117. }
  118.  
  119. rowvalueize(arg)
  120. {
  121.     valueize_area(currow, 0, currow + arg - 1, maxcol);
  122. }
  123.  
  124. colvalueize(arg)
  125. {
  126.     valueize_area(0, curcol, maxrow, curcol + arg - 1);
  127. }
  128.  
  129. erase_area(sr, sc, er, ec)
  130. int sr, sc, er, ec;
  131. {
  132.     register int r, c;
  133.     register struct ent **p;
  134.  
  135.     if (sr > er) {
  136.     r = sr; sr = er; er= r;    
  137.     }
  138.  
  139.     if (sc > ec) {
  140.     c = sc; sc = ec; ec= c;    
  141.     }
  142.  
  143.     if (sr < 0)
  144.     sr = 0; 
  145.     if (sc < 0)
  146.     sc = 0;
  147.     if (er >= MAXROWS)
  148.     er = MAXROWS-1;
  149.     if (ec >= MAXCOLS)
  150.     ec = MAXCOLS-1;
  151.  
  152.     for (r = sr; r <= er; r++) {
  153.     for (c = sc; c <= ec; c++) {
  154.         p = &tbl[r][c];
  155.         if (*p) {
  156.         free_ent(*p);
  157.         *p = 0;
  158.         }
  159.     }
  160.     }
  161.  
  162. }
  163.  
  164. valueize_area(sr, sc, er, ec)
  165. int sr, sc, er, ec;
  166. {
  167.     register int r, c;
  168.     register struct ent *p;
  169.  
  170.     if (sr > er) {
  171.     r = sr; sr = er; er= r;    
  172.     }
  173.  
  174.     if (sc > ec) {
  175.     c = sc; sc = ec; ec= c;    
  176.     }
  177.  
  178.     if (sr < 0)
  179.     sr = 0; 
  180.     if (sc < 0)
  181.     sc = 0;
  182.     if (er >= MAXROWS)
  183.     er = MAXROWS-1;
  184.     if (ec >= MAXCOLS)
  185.     ec = MAXCOLS-1;
  186.  
  187.     for (r = sr; r <= er; r++) {
  188.     for (c = sc; c <= ec; c++) {
  189.         p = tbl[r][c];
  190.         if (p && p->expr) {
  191.         efree(p->expr);
  192.         p->expr = 0;
  193.         p->flags &= ~is_strexpr;
  194.         }
  195.     }
  196.     }
  197.  
  198. }
  199.  
  200. pullcells(to_insert)
  201. {
  202.     register struct ent *p, *n;
  203.     register int deltar, deltac;
  204.     int minrow, mincol;
  205.     int mxrow, mxcol;
  206.     int numrows, numcols;
  207.  
  208.     if (!to_fix)
  209.     return;
  210.  
  211.     switch (to_insert) {
  212.     case 'm':
  213.     case 'r':
  214.     case 'c':
  215.     break;
  216.     default:
  217.     error("Invalid pull command");
  218.     return;
  219.     }
  220.  
  221.     minrow = MAXROWS; 
  222.     mincol = MAXCOLS;
  223.     mxrow = 0;
  224.     mxcol = 0;
  225.  
  226.     for (p = to_fix; p; p = p->next) {
  227.     if (p->row < minrow)
  228.         minrow = p->row;
  229.     if (p->row > mxrow)
  230.         mxrow = p->row;
  231.     if (p->col < mincol)
  232.         mincol = p->col;
  233.     if (p->col > mxcol)
  234.         mxcol = p->col;
  235.     }
  236.  
  237.     numrows = mxrow - minrow + 1;
  238.     numcols = mxcol - mincol + 1;
  239.     deltar = currow - minrow;
  240.     deltac = curcol - mincol;
  241.  
  242.     if (to_insert == 'r') {
  243.     insertrow(numrows);
  244.     deltac = 0;
  245.     } else if (to_insert == 'c') {
  246.     insertcol(numcols);
  247.     deltar = 0;
  248.     }
  249.  
  250.     FullUpdate++;
  251.     modflg++;
  252.  
  253.     for (p = to_fix; p; p = p->next) {
  254.     n = lookat (p->row + deltar, p->col + deltac);
  255.     (void) clearent(n);
  256.     n -> flags = p -> flags & ~is_deleted;
  257.     n -> v = p -> v;
  258.     n -> expr = copye(p->expr, deltar, deltac);
  259.     n -> label = 0;
  260.     if (p -> label) {
  261.         n -> label = (char *)
  262.              xmalloc((unsigned)(strlen(p->label)+1));
  263.         (void) strcpy (n -> label, p -> label);
  264.     }
  265.     }
  266. }
  267.  
  268. colshow_op()
  269. {
  270.     register int i,j;
  271.     for (i=0; i<MAXCOLS; i++)
  272.     if (col_hidden[i]) 
  273.         break;
  274.     for(j=i; j<MAXCOLS; j++)
  275.     if (!col_hidden[j])
  276.         break;
  277.     j--;
  278.     if (i<MAXCOLS) {
  279.     (void) sprintf(line,"show %s:", coltoa(i));
  280.     (void) sprintf(line + strlen(line),"%s",coltoa(j));
  281.     linelim = strlen (line);
  282.     }
  283. }
  284.  
  285. rowshow_op()
  286. {
  287.     register int i,j;
  288.     for (i=0; i<MAXROWS; i++)
  289.     if (row_hidden[i]) 
  290.         break;
  291.     for(j=i; j<MAXROWS; j++)
  292.     if (!row_hidden[j]) {
  293.         break;
  294.     }
  295.     j--;
  296.     if (i<MAXROWS) {
  297.     (void) sprintf(line,"show %d:%d", i, j);
  298.         linelim = strlen (line);
  299.     }
  300. }
  301.  
  302. get_qual()
  303. {
  304.     register int c;
  305.  
  306.     c = nmgetch();
  307.     switch (c) {
  308.     case 'c':
  309.     case 'j':
  310.     case 'k':
  311.     case ctl(p):
  312.     case ctl(n):
  313.     return('c');
  314.     case 'r':
  315.     case 'l':
  316.     case 'h':
  317.     case ctl(f):
  318.     case ctl(b):
  319.     return('r');
  320.     default:
  321.     return(c);
  322.     }
  323.     /*NOTREACHED*/
  324. }
  325.  
  326. openrow (rs) {
  327.     register    r;
  328.     register struct ent **p;
  329.     register    c;
  330.     register    i;
  331.  
  332.     if (rs > maxrow) maxrow = rs;
  333.     if (maxrow >= MAXROWS - 1 || rs > MAXROWS - 1) {
  334.     error ("The table can't be any longer");
  335.     return;
  336.     }
  337.     for (i = maxrow+1; i > rs; i--) {
  338.     row_hidden[i] = row_hidden[i-1];
  339.     }
  340.     for (r = ++maxrow; r > rs; r--)
  341.     for (c = maxcol + 1, p = &tbl[r][0]; --c >= 0; p++)
  342.         if (p[0] = p[-MAXCOLS])
  343.         p[0] -> row++;
  344.     p = &tbl[rs][0];
  345.     for (c = maxcol + 1; --c >= 0;)
  346.     *p++ = 0;
  347.     FullUpdate++;
  348.     modflg++;
  349. }
  350.  
  351. closerow (r)
  352. register r; {
  353.     register struct ent **p;
  354.     register c;
  355.     register int i;
  356.  
  357.     if (r > maxrow) return;
  358.  
  359.     p = &tbl[r][0];
  360.     for (c=maxcol+1; --c>=0; ) {
  361.     if (*p)
  362.         free_ent(*p);
  363.     *p++ = 0;
  364.     }
  365.  
  366.     for (i = r; i < MAXROWS - 1; i++) {
  367.     row_hidden[i] = row_hidden[i+1];
  368.     }
  369.  
  370.     while (r<maxrow) {
  371.     for (c = maxcol+1, p = &tbl[r][0]; --c>=0; p++)
  372.         if (p[0] = p[MAXCOLS])
  373.         p[0]->row--;
  374.     r++;
  375.     }
  376.  
  377.     p = &tbl[maxrow][0];
  378.     for (c=maxcol+1; --c>=0; ) *p++ = 0;
  379.     maxrow--;
  380.     FullUpdate++;
  381.     modflg++;
  382. }
  383.  
  384. opencol (cs) {
  385.     register r;
  386.     register struct ent **p;
  387.     register c;
  388.     register lim = maxcol-cs+1;
  389.     int i;
  390.  
  391.     if (cs > maxcol) maxcol = cs;
  392.     if (maxcol >= MAXCOLS - 1 || cs > MAXCOLS - 1) {
  393.     error ("The table can't be any wider");
  394.     return;
  395.     }
  396.     for (i = maxcol+1; i > cs; i--) {
  397.     fwidth[i] = fwidth[i-1];
  398.     precision[i] = precision[i-1];
  399.     col_hidden[i] = col_hidden[i-1];
  400.     }
  401.     /* fwidth[cs] = DEFWIDTH;
  402.     precision[i] =  DEFPREC;  */
  403.  
  404.     for (r=0; r<=maxrow; r++) {
  405.     p = &tbl[r][maxcol+1];
  406.     for (c=lim; --c>=0; p--)
  407.         if (p[0] = p[-1])
  408.         p[0]->col++;
  409.     p[0] = 0;
  410.     }
  411.     maxcol++;
  412.     FullUpdate++;
  413.     modflg++;
  414. }
  415.  
  416. closecol (cs) {
  417.     register r;
  418.     register struct ent **p;
  419.     register struct ent *q;
  420.     register c;
  421.     register lim = maxcol-cs;
  422.     int i;
  423.  
  424.     if (lim < 0) return;
  425.  
  426.     for (r=0; r<=maxrow; r++)
  427.     if (q = tbl[r][cs]) {
  428.         free_ent(q);
  429.     }
  430.  
  431.     for (r=0; r<=maxrow; r++) {
  432.     p = &tbl[r][cs];
  433.     for (c=lim; --c>=0; p++)
  434.         if (p[0] = p[1])
  435.         p[0]->col--;
  436.     p[0] = 0;
  437.     }
  438.  
  439.     for (i = cs; i < MAXCOLS - 1; i++) {
  440.     fwidth[i] = fwidth[i+1];
  441.     precision[i] = precision[i+1];
  442.     col_hidden[i] = col_hidden[i+1];
  443.     }
  444.  
  445.     maxcol--;
  446.     FullUpdate++;
  447.     modflg++;
  448. }
  449.  
  450. doend(rowinc, colinc)
  451. {
  452.     register struct ent *p;
  453.     int r, c;
  454.  
  455.     if (VALID_CELL(p, currow, curcol)) {
  456.     r = currow + rowinc;
  457.     c = curcol + colinc;
  458.     if (r >= 0 && r < MAXROWS && 
  459.         c >= 0 && c < MAXCOLS &&
  460.         !VALID_CELL(p, r, c)) {
  461.         currow = r;
  462.         curcol = c;
  463.     }
  464.     }
  465.  
  466.     if (!VALID_CELL(p, currow, curcol)) {
  467.         switch (rowinc) {
  468.         case -1:
  469.         while (!VALID_CELL(p, currow, curcol) && currow > 0)
  470.         currow--;
  471.         break;
  472.         case  1:
  473.         while (!VALID_CELL(p, currow, curcol) && currow < MAXROWS-1)
  474.         currow++;
  475.         break;
  476.         case  0:
  477.             switch (colinc) {
  478.          case -1:
  479.             while (!VALID_CELL(p, currow, curcol) && curcol > 0)
  480.             curcol--;
  481.             break;
  482.          case  1:
  483.             while (!VALID_CELL(p, currow, curcol) && curcol < MAXCOLS-1)
  484.             curcol++;
  485.             break;
  486.         }
  487.             break;
  488.         }
  489.     return;
  490.     }
  491.  
  492.     switch (rowinc) {
  493.     case -1:
  494.     while (VALID_CELL(p, currow, curcol) && currow > 0)
  495.         currow--;
  496.     break;
  497.     case  1:
  498.     while (VALID_CELL(p, currow, curcol) && currow < MAXROWS-1)
  499.         currow++;
  500.     break;
  501.     case  0:
  502.     switch (colinc) {
  503.     case -1:
  504.         while (VALID_CELL(p, currow, curcol) && curcol > 0)
  505.         curcol--;
  506.         break;
  507.     case  1:
  508.         while (VALID_CELL(p, currow, curcol) && curcol < MAXCOLS-1)
  509.         curcol++;
  510.         break;
  511.     }
  512.     break;
  513.     }
  514.     if (!VALID_CELL(p, currow, curcol)) {
  515.         currow -= rowinc;
  516.         curcol -= colinc;
  517.     }
  518. }
  519.  
  520. doformat(c1,c2,w,p)
  521. int c1,c2,w,p;
  522. {
  523.     register int i;
  524.  
  525.     if (w > COLS - RESCOL - 2) {
  526.     error("Format too large - Maximum = %d", COLS - RESCOL - 2);
  527.     w = COLS-RESCOL-2;
  528.     }
  529.  
  530.     if (p > w) {
  531.     error("Precision too large");
  532.     p = w;
  533.     }
  534.  
  535.     for(i = c1; i<=c2; i++)
  536.     fwidth[i] = w, precision[i] = p;
  537.  
  538.     FullUpdate++;
  539.     modflg++;
  540. }
  541.